#include "game.h"


void draw_background(char * base,char * table){
    clear_screen(0,base);
    draw_frame(0,156, HRES, VRES-156, base);
    
    Sprite *ht1 = create_sprite(heart,base,10,32);
    Sprite *ht2 = create_sprite(heart,base,100*1+10*2,32);
    Sprite *ht3 = create_sprite(heart,base,100*2+10*3,32);
    draw_sprite(ht1,base);
    draw_sprite(ht2,base);
    draw_sprite(ht3,base);   
    free(ht1);
    free(ht2);
    free(ht3);

    drawStringAt("Time: ", 720, 46, 1, 0, 4, base, table);
}

void show_credits(){
    clean_text_screen();
    int i;
    for(i =0; i < HEIGHT_TEXT; i++)
        printStringAt(credits[i],0,i, NORMAL);
}

void lose_life(char *base){
    int x;
    x = 100*(lives-1)+10*lives; 
    clear_partial_screen(x,32,x+100,32+100,base);
    lives--;
}

int menu(char* base, char* table){
	clear_screen(0,base);
    draw_frame(0,0,HRES,VRES,base);
    drawStringAt("QIX", 365, 60,10, 0, 10, base, table);
    drawStringAt("    GAME   ", 260, 350, 2, 0, 5, base, table);
    drawStringAt("HIGH SCORES", 280, 500, 5, 0, 5, base, table);
    drawStringAt("    EXIT   ", 260, 650, 4, 0, 5, base, table);
    drawRectangle(260, 350, 2, 16*5, 12*8*5, false, base);
	drawRectangle(260, 500, 5, 16*5, 12*8*5, false, base);
	drawRectangle(260, 650, 4, 16*5, 12*8*5, false, base);
    
    
    
    /*
    Sprite *sp1 = create_sprite(penguin,base,100,350);
    Sprite *sp2 = create_sprite(penguin,base,900,350);
    Sprite *sp3 = create_sprite(ball,base,100,100);
   
    
    
    char*buffer = malloc(HRES*VRES*sizeof(char));
    memcpy(buffer,base,HRES*VRES);
    
    int i = 0;
    while(i < 1000){
        
        animate_sprite(sp1,buffer);
        animate_sprite(sp2,buffer);
        draw_sprite(sp1,buffer);
        draw_sprite(sp2,buffer);
        draw_sprite(sp3,buffer);
        
        
        
         memcpy(base,buffer,HRES*VRES);
         
         i++;
        
    }
    
    free(buffer);
    */
    return 0;
    
}

///////////////////PONTUACOES/////////////////////////////

void pontuacoesInit(Pontuacao** pontuacoes, int size){
	int i;
	for(i = 0; i < size; i++)
		pontuacaoInit(pontuacoes[i]);
}

void pontuacaoInit(Pontuacao* pontuacao){
	pontuacao->nome = (char*)malloc(NOME_SIZE*sizeof(char));
	memset(pontuacao->nome, '\0', NOME_SIZE);
	pontuacao->pontos = 0;
	pontuacao->dia = 1;
	pontuacao->mes = 1;
	pontuacao->ano = 10;
}

void pontuacoesFree(Pontuacao** pontuacoes, int size){
	int i;
	for(i = 0; i < size; i++)
		pontuacaoFree(pontuacoes[i]);
}

void pontuacaoFree(Pontuacao* pontuacao){
	free(pontuacao->nome);
}

void printPontuacoes(Pontuacao** pontuacoes, int xt, int xp, int xd, int y, char* base, char* table){
	
	// modo grafico
	drawStringAt("QIX PONTUACOES", xp - 6*(16*3/2), y - 2*(16*3), 15, 0, 3, base, table);
	drawStringAt("NOME", xt, y, 15, 0, 1, base, table);
	drawStringAt("PONTOS", xp - 1*8, y, 15, 0, 1, base, table);
	drawStringAt("DATA", xd + 3*8, y, 15, 0, 1, base, table);
	y +=2*16;
	
	int i;
	for(i = 0; i < PONTUACOES_SIZE; i++){
		printPontuacao(pontuacoes[i], xt, xp, xd, y+i*16, base, table);
		y += 8;
		// y += 12; // linha dupla
	}
}

void printPontuacao(Pontuacao* pontuacao, int xt, int xp, int xd, int y, char* base, char* table){
	drawStringAt(pontuacao->nome, xt, y, 15, 0, 1, base, table);
	drawIntAt(pontuacao->pontos, xp, y, 15, 0, 1, base, table);

	if(pontuacao->dia < 10){
		drawIntAt(0, xd, y, 15, 0, 1, base, table);
		drawIntAt(pontuacao->dia, xd + 1*8, y, 15, 0, 1, base, table);
	}
	else
		drawIntAt(pontuacao->dia, xd, y, 15, 0, 1, base, table);

	drawStringAt("-", xd+8*2, y, 15, 0, 1, base, table);

	if(pontuacao->mes < 10){
		drawIntAt(0, xd + 3*8, y, 15, 0, 1, base, table);
		drawIntAt(pontuacao->mes, xd + 4*8, y, 15, 0, 1, base, table);
	}
	else
		drawIntAt(pontuacao->mes, xd + 3*8, y, 15, 0, 1, base, table);

	drawStringAt("-", xd+8*5, y, 15, 0, 1, base, table);

	drawIntAt(pontuacao->ano + 2000, xd + 6*8, y, 15, 0, 1, base, table);
}

int loadPontuacoes(char* filename, Pontuacao** pontuacoes, int size){
	
	FILE* file;

	if((file = fopen(filename, "r")) == NULL){
		perror("Erro: loading pontuacoes.\n");
		return -1;
	}

	int i;
	for(i = 0; i < PONTUACOES_SIZE; i++){
		fscanf(file, "%s", pontuacoes[i]->nome);
		fscanf(file, "%d", &pontuacoes[i]->pontos);
		fscanf(file, "%d", &pontuacoes[i]->dia);
		fscanf(file, "%d", &pontuacoes[i]->mes);
		fscanf(file, "%d", &pontuacoes[i]->ano);
	}
	
	fclose(file);
	return 0;
}

int compare_pontuacao (const void * a, const void * b){
  if( (int)(*(Pontuacao*)b).pontos - (int)(*(Pontuacao*)a).pontos  == 0)
	  return ( ((int)(*(Pontuacao*)b).dia + (int)(*(Pontuacao*)b).mes * 30 + (int)(*(Pontuacao*)b).ano * 356) - 
				((int)(*(Pontuacao*)a).dia + (int)(*(Pontuacao*)a).mes * 30 + (int)(*(Pontuacao*)a).ano * 356) );
  else
	return (int)(*(Pontuacao*)b).pontos - (int)(*(Pontuacao*)a).pontos;
				
}

int savePontuacoes(char* filename, Pontuacao** pontuacoes, int size){

	FILE* file1;

	if((file1 = fopen(filename, "w")) == NULL){
		perror("Erro: saving pontuacoes.\n");
		return -1;
	}

	int i;
	for(i = 0; i < PONTUACOES_SIZE; i++)
		fprintf(file1, "%s %d %d %d %d\n", pontuacoes[i]->nome, pontuacoes[i]->pontos,
				pontuacoes[i]->dia, pontuacoes[i]->mes, pontuacoes[i]->ano);

	fclose(file1);
	return 0;

}

void show_pontuacoes(Pontuacao** pontuacoes, int size, char* base, char* table){
	// modo grafico
	clear_screen(0, base);
	draw_frame(0, 0, HRES, VRES, base);
	drawStringAt("Right mouse button to go back", 13, 768-13-16, 15, 0, 1, base, table);
	//qsort(pontuacoes, size, sizeof(Pontuacao), compare_pontuacao);

	int max_size = 0, i;
	for(i = 0; i < PONTUACOES_SIZE; i++)
		if(strlen(pontuacoes[i]->nome) > max_size)
			max_size = strlen(pontuacoes[i]->nome);
	
	// modo grafico
	int coluna_inicio_nome =   (int)(HRES / 2 - max_size*8 - 8*8);
	int coluna_inicio_pontos = (int)(coluna_inicio_nome + max_size*8 + 4*8);
	int coluna_inicio_data =   (int)(coluna_inicio_pontos + 4*8 + 5*8);
	int linha_inicio =         (int)(VRES / 3);
	//int linha_inicio =         (int)(HEIGHT_TEXT / 8); // linha dupla
	
	printPontuacoes(pontuacoes, coluna_inicio_nome, coluna_inicio_pontos, coluna_inicio_data, linha_inicio, base, table);
}

int getPontuacaoMin(Pontuacao** arr, int size){
	int i, min = arr[0]->pontos;
	for(i = 0; i < size; i++)
		if(arr[i]->pontos < min)
			 min = arr[i]->pontos;
	return min;
}

void remnewline(char * buffer){
	int i = strlen(buffer) - 1;
	while(buffer[i] == '\n')buffer[i] = '\0';
}

/* Algoritmo secundário de organização da Pontuacao
void organizarPontuacoes(Pontuacao** pontuacoes, Pontuacao* pontuacao, int size){
	
	Pontuacao** tmp;
	tmp = (Pontuacao**)malloc(size*sizeof(Pontuacao*));
	int j;
	for(j = 0; j < size; j++)
		tmp[j] = (Pontuacao*)malloc(sizeof(Pontuacao));
	pontuacoesInit(tmp, size);
	
	Bool entrou = false;
	
	int i;
	for(i = 0; i < size; i++){
		if(pontuacoes[i]->pontos < pontuacao->pontos && entrou == false){
			tmp[i] = pontuacao;
			entrou = true;
			i--;
		}
		else
			tmp[i] = pontuacoes[i];
	}
	
	pontuacoes = tmp;
}*/

Pontuacao* criaPontuacao(char* nome, int pontos, int dia, int mes, int ano){

	Pontuacao* nova = (Pontuacao*)malloc(sizeof(Pontuacao));;
	pontuacaoInit(nova);

	nova->nome = nome;
	nova->pontos = pontos;
	nova->dia = dia;
	nova->mes = mes;
	nova->ano = ano;
	
	return nova;
}
///////////////////STACK/////////////////////////////

void initStack(Stack* st, int size){
	st->contents = (int*)malloc(size*sizeof(int));
	st->top = 0;
	st->maxSize = size;
}

void freeStack(Stack* st){
	free(st->contents);
}

Bool emptyStack(Stack* st){
	if(st->top == 0)
		return true;
	else
		return false;
}

void push(Stack* st, int val){
	if(st->top != st->maxSize)
		st->contents[st->top++] = val;
}

void pop(Stack* st){
	if(!emptyStack(st))
		st->top--;
}

int sizeStack(Stack* st){
	return st->top;
}

// nao tem verificação de pilha vazia :S
int top(Stack* st){
	return st->contents[st->top-1];
}
